import { defAxios as request } from '@/utils/http';
import { ref, watch, computed, reactive, nextTick } from 'vue';
import { compProps, defaultProps } from '../cfg/table-props';
import XEUtils from 'xe-utils';

export const ReqParamTypeEnums = ['params', 'data'];

export const useProxyConfig = ({ props, attrs, emits, gridRef, gridOptions }) => {
	// 查询参数
	const queryParams = ref({});
	const cacheParams = ref({});

	// 监听查询参数信息
	watch(
		() => props.params,
		(newValue, oldValue) => {
			if (!XEUtils.isEmpty(newValue)) queryParams.value = newValue;
		},
		{ deep: true, immediate: false }
	);

	// 是否开启分页器
	const paginationOpened = computed(() => {
		const { pagerConfig } = props
		let finalValue = false
		if (XEUtils.isBoolean(pagerConfig)) {
			finalValue = pagerConfig
		} else if (XEUtils.isObject(pagerConfig)) {
			finalValue = pagerConfig.enabled
		}
		return finalValue
	})

	/** 初始化数据代理配置 */
	const initProxyConfig = () => {
		const { dataUrl, params, autoLoad } = props;
		// 存在静态参数时，不采取操作
		if (attrs.data) return;
		// 如果参数不为空，缓存初始参数，用于重置参数
		if (!XEUtils.isEmpty(params)) {
			queryParams.value = props.params
			cacheParams.value = XEUtils.clone(props.params, true)
		};
		// dataUrl没传，值为 undefined | null，不采取操作
		if (dataUrl === undefined || dataUrl === null) {
			console.warn('dataUrl值不能为undefined或null!');
			return;
		}
		if (dataUrl) {
			const proxyConfig = {
				...defaultProps.proxyConfig,
				autoLoad,
				ajax: { query: (values) => initProxyQuery(values) },
			};
			gridOptions['proxyConfig'] = proxyConfig;
		} else {
			console.warn('dataUrl值不能为空!');
		}
	};

	/**
	 * 初始化数据查询代理
	 * @param {Object} param 代理查询参数
	 * @returns Promise
	 */
	const initProxyQuery = ({ page }) => {
		const requestQuery = getRequestQuery({
			page, ...props,
			params: queryParams.value,
		});
		const { responseHandle } = props;
		const proxyProps = defaultProps.proxyConfig.props;
		return new Promise((reslove) => {
			setTimeout(() => {
				let tableData = [];
				let finalData = [];
				requestQuery
					.then((res) => {
						const { code, data, msg } = res;
						if (code === 200) {
							tableData = paginationOpened.value ? data.rows : data;
							// 数据回调处理
							if (responseHandle) tableData = responseHandle(tableData);
							// 判断是否分页
							if (paginationOpened.value) {
								finalData = {
									[proxyProps.total]: data.records,
									[proxyProps.result]: tableData,
								};
							} else {
								
								if (!XEUtils.isArray(tableData)) {
									console.warn(`数据为分页数据，请检查配置 "pagerConfig" `)
									finalData = []
								} else {
									finalData = tableData;
								}
							}
						} else {
							console.warn(msg);
							if (paginationOpened.value) {
								finalData = {
									[proxyProps.total]: 0,
									[proxyProps.result]: [],
								};
							}
						}
						reslove(finalData);
						emits('loaded', finalData);
					})
					.catch((err) => {
						if (paginationOpened.value) {
							finalData = {
								[proxyProps.total]: 0,
								[proxyProps.result]: [],
							};
						}
						reslove(finalData);
						emits('loaded', finalData);
					});
			}, 100);
		});
	};
	/**
	 * 获取请求代理对象
	 * @param {Object} options 配置参数
	 * @returns axios
	 */
	const getRequestQuery = (options) => {
		const { page, params, method, dataUrl, paramsType, restful } = options;
		const finalOptions = {
			url: dataUrl,
			method: method,
		};
		// 封装分页参数
		let pageParams = {};
		if (paginationOpened.value) {
			pageParams = {
				page: page.currentPage,
				pageSize: page.pageSize,
			};
		}
		
		// 最终的参数
		const finalParams = {
			...XEUtils.clone(params, true),
			...pageParams,
		};
		// 如果是resFul风格对请求参数进行替换
		if (restful) {
			finalOptions.url = finalOptions.url.replace(/\{(\w+)\}/g, (match, p1) => {
				return finalParams[p1] || match // 若数据不存在则保留原占位符
			})
		} else {
			// 封装请求参数
			let type = method.toLowerCase() === 'post' ? (ReqParamTypeEnums.includes(paramsType) ? paramsType : 'data') : 'params';
			finalOptions[type] = finalParams;
		}
		return props.request ? props.request(finalOptions) : request(finalOptions);
	};

	/**
	 * 重置查询参数
	 *
	 * @param { Object } params 查询参数
	 * @returns { Object } 缓存的查询参数
	 */
	const resetParams = (params = {}) => {
		if (!params) return {}
		const oldParams = XEUtils.clone(cacheParams.value, true)
		queryParams.value = { ...oldParams, ...params }
		return oldParams
	}

	/**
	 * 合并查询参数
	 *
	 * @param { Object } params 查询参数
	 * @returns { Object } 缓存的查询参数
	 */
	const mergeParams = (params = {}) => {
		if (!params) return {}
		let newParams = XEUtils.clone(queryParams.value, true)
		newParams = { ...newParams, ...params }
		queryParams.value = newParams
		return XEUtils.clone(newParams, true)
	}

	return { initProxyConfig, resetParams, mergeParams, queryParams };
};
